package gladiatormanager;

import java.awt.Point;
import java.awt.geom.Point2D;
import java.io.File;
import java.text.DecimalFormat;
import java.util.ArrayList;
import org.lwjgl.LWJGLUtil;
import org.newdawn.slick.Input;
import org.newdawn.slick.AppGameContainer;
import org.newdawn.slick.BasicGame;
import org.newdawn.slick.Color;
import org.newdawn.slick.GameContainer;
import org.newdawn.slick.Graphics;
import org.newdawn.slick.Image;
import org.newdawn.slick.SlickException;


public class GladiatorManager extends BasicGame {
        private static final int LEVEYS = 600;
        private static final int KORKEUS = 600;
        private final int XRUUTUJA = 20;
        private final int YRUUTUJA = 20;
        private final int RUUDUN_LEVEYS = LEVEYS/XRUUTUJA;
        private final int RUUDUN_KORKEUS = KORKEUS/YRUUTUJA;
        private static final int INFO_LEVEYS = 400;
        private static final int TEKSTI_KORKEUS = 20;
        private final int TILA_PELI_ALKU = 0;
        private final int TILA_PELI = 1;
        private final int TILA_PELI_ALOITA_UUSI = 2;
        private final int TILA_PELI_PUNAINENVOITTI = 3;
        private final int TILA_PELI_SININENVOITTI = 4;
        private final int MONTAKO_VALITAAN = 10;
        private final int BUTTON_NEWGAME_X = LEVEYS+5;
        private final int BUTTON_NEWGAME_Y = KORKEUS-25;
        private final int BUTTON_BAG_X = LEVEYS+5;
        private final int BUTTON_BAG_Y = KORKEUS-55;
        private final int BUTTON_WALK_X = LEVEYS+5;
        private final int BUTTON_WALK_Y = KORKEUS-85;
        private final int BUTTON_ENDTURN_X = LEVEYS+5;
        private final int BUTTON_ENDTURN_Y = KORKEUS-115;
                
        private int pelinTila, siirtoVuoro, valittuja;
        private Ruudukko ruudukko;
        private Image punainen;
        private Image sininen;
        private Image vihrea;
        private Image tausta;
        private Image[] glads;
        private Image button_newgame;
        private Input input;
        private double[][] kavelymahdollisuudet;
        private boolean imagesLoaded = false;
        //private ArrayList<Gladiaattori> gladiaattoriLista = new ArrayList<Gladiaattori>();
        private Image button_bag;
        private Image button_walk;
        private Image button_hit;
        private Image button_endturn;
	
	public GladiatorManager() {
		super("Gladiator game");
	}
        
        
        private void initGladiaattorit() {
            Gladiaattori g1 = new Gladiaattori(0, 10, 10, 25, 40, glads[0]);
            Gladiaattori g2 = new Gladiaattori(0, 10, 10, 22, 50, glads[1]);
            Gladiaattori g3 = new Gladiaattori(0, 10, 10, 25, 54, glads[2]);
            Gladiaattori g4 = new Gladiaattori(0, 10, 10, 27, 55, glads[3]);
            Gladiaattori g5 = new Gladiaattori(0, 10, 10, 26, 52, glads[4]);
            Gladiaattori g6 = new Gladiaattori(0, 10, 10, 22, 46, glads[5]);
            Gladiaattori g7 = new Gladiaattori(0, 10, 10, 20, 58, glads[6]);        
            Gladiaattori g8 = new Gladiaattori(0, 10, 10, 29, 44, glads[7]);        
            Gladiaattori g9 = new Gladiaattori(0, 10, 10, 27, 48, glads[8]);        
            Gladiaattori g10 = new Gladiaattori(0, 10, 10, 28, 47, glads[9]);
            g1.lisaaTavara(new Ase("Magic wand", 1, 3, 7, 5, false), true);
            g1.lisaaTavara(new Ase("Sword", 3, 6, 1, 5, false), false);
            g1.lisaaTavara(new Haarniska("Body armour", 4, 2, PuettavaTavara.HAARNISKA), true);
            g2.lisaaTavara(new Ase("Spear", 2, 4, 2, 5, true), true);
            g2.lisaaTavara(new Ase("Bow", 2, 3, 5, 5, false), false);
            g3.lisaaTavara(new Ase("Axe", 3, 6, 1, 5, false), true);
            g4.lisaaTavara(new Ase("Longbow", 3, 5, 10, 10, true), true);
            g5.lisaaTavara(new Ase("Axe", 3, 6, 1, 5, false), true);
            g6.lisaaTavara(new Ase("Mace", 3, 3, 2, 6, true), true);
            g6.lisaaTavara(new Haarniska("Body armour", 4, 3, PuettavaTavara.HAARNISKA), true);
            g6.lisaaTavara(new Haarniska("Leg armour", 2, 2, PuettavaTavara.JALKAHAARNISKA), true);
            g6.lisaaTavara(new Haarniska("Helmet", 1, 1, PuettavaTavara.KYPARA), true);
            g7.lisaaTavara(new Ase("Sword", 3, 6, 1, 5, false), true);
            g8.lisaaTavara(new Ase("Magic staff", 3, 6, 7, 5, false), true);
            g9.lisaaTavara(new Ase("Sword", 3, 6, 1, 5, false), true);
            ruudukko.lisaaGladiaattori(g1, 6, 9);
            ruudukko.lisaaGladiaattori(g2, 6, 10);
            ruudukko.lisaaGladiaattori(g3, 8, 9);
            ruudukko.lisaaGladiaattori(g4, 8, 10);
            ruudukko.lisaaGladiaattori(g5, 10, 9);
            ruudukko.lisaaGladiaattori(g6, 10, 10);
            ruudukko.lisaaGladiaattori(g7, 12, 9);
            ruudukko.lisaaGladiaattori(g8, 12, 10);
            ruudukko.lisaaGladiaattori(g9, 14, 9);
            ruudukko.lisaaGladiaattori(g10, 14, 10);
        }
        
        private void lataaKuvat() throws SlickException {
            tausta = new Image("tausta.jpg");
            tausta = tausta.getScaledCopy(LEVEYS, KORKEUS);
            punainen = new Image("punainen.jpg");
            punainen.setAlpha((float)0.5);
            sininen = new Image("sininen.jpg");
            sininen.setAlpha((float)0.5);
            vihrea = new Image("vihrea.jpg");
            vihrea.setAlpha((float)0.6);
            button_newgame = new Image("button_newgame.jpg", Color.white);
            button_bag = new Image("button_bag.jpg", Color.white);
            button_walk = new Image("button_walk.jpg", Color.white);
            button_hit = new Image("button_hit.jpg", Color.white);
            button_endturn = new Image("button_endturn.jpg", Color.white);
            glads = new Image[10];
            for (int i = 0; i < glads.length; i++) {
                glads[i] = new Image("glad"+(i+1)+".gif", Color.white);
            }
        }
        
	@Override
	public void init(GameContainer gc) throws SlickException {
                kavelymahdollisuudet = null;
                valittuja = 0;
                ruudukko = new Ruudukko(20, 20);
                pelinTila = TILA_PELI_ALKU;
                siirtoVuoro = Joukkue.PUNAINEN;
                if (!imagesLoaded) {
                    lataaKuvat();
                    imagesLoaded = true;
                }
                initGladiaattorit();
	}

	@Override
            
	public void update(GameContainer gc, int delta) throws SlickException {
            if (pelinTila == TILA_PELI_ALOITA_UUSI) {
                pelinTila = TILA_PELI_ALKU;
                gc.reinit();
            }
	}

	@Override
	public void render(GameContainer gc, Graphics g) throws SlickException {   
		g.setBackground(Color.darkGray);
                tausta.draw();
                g.setColor(Color.white);
                if (ruudukko.getValittu() != null) {
                    
                }
                g.drawString("Player "+siirtoVuoro+" TURN!", 10, KORKEUS);
                button_newgame.draw(BUTTON_NEWGAME_X, BUTTON_NEWGAME_Y);
                if (pelinTila == TILA_PELI) button_endturn.draw(BUTTON_ENDTURN_X, BUTTON_ENDTURN_Y);
                Point p = ruudukko.getValittuLocation();
                Point p2 = ruudukko.getVuoroLocation();
                if (p2 != null) {
                    Gladiaattori v = ruudukko.getVuoro().getGladiaattori();
                    if (siirtoVuoro == Joukkue.PUNAINEN) {
                        punainen.draw((int)p2.getX()*RUUDUN_LEVEYS, (int)p2.getY()*RUUDUN_KORKEUS);
                    } else sininen.draw((int)p2.getX()*RUUDUN_LEVEYS, (int)p2.getY()*RUUDUN_KORKEUS);
                    //vihrea.draw((int)p2.getX()*RUUDUN_LEVEYS, (int)p2.getY()*RUUDUN_KORKEUS);
                } else if (p != null) {
                    Gladiaattori v = ruudukko.getValittu().getGladiaattori();
                    if (siirtoVuoro == Joukkue.PUNAINEN) {
                        punainen.draw((int)p.getX()*RUUDUN_LEVEYS, (int)p.getY()*RUUDUN_KORKEUS);
                    } else sininen.draw((int)p.getX()*RUUDUN_LEVEYS, (int)p.getY()*RUUDUN_KORKEUS);
                }
                if (p != null) {
                    Gladiaattori valittuGladiaattori = ruudukko.getValittu().getGladiaattori();
                    button_bag.draw(BUTTON_BAG_X, BUTTON_BAG_Y);
                    g.drawString(valittuGladiaattori.getReppu().toString2(), BUTTON_BAG_X+button_bag.getWidth(), BUTTON_BAG_Y);
                    valittuGladiaattori.getImage().draw(LEVEYS+5, 5);
                    g.drawString(valittuGladiaattori.toString(), LEVEYS+5, 40);
                    if (pelinTila == TILA_PELI_ALKU){
                        if (valittuGladiaattori.getJoukkue() == Joukkue.TYHJA) {   
                            int y = 0;
                            if (siirtoVuoro == Joukkue.PUNAINEN) y = YRUUTUJA-3;
                            for (int xx = 0; xx < XRUUTUJA; xx++) {
                                for (int yy = y; yy < y+3; yy++) {
                                    if (ruudukko.getRuutu(xx, yy).kaveltava() == true) {
                                        if (siirtoVuoro == Joukkue.PUNAINEN) {
                                            punainen.draw(xx*RUUDUN_LEVEYS, yy*RUUDUN_KORKEUS);
                                        } else {
                                            sininen.draw(xx*RUUDUN_LEVEYS, yy*RUUDUN_KORKEUS);
                                        }
                                    }
                                }
                            }
                            ruudukko.getRuutu(0, 0);
                            if (siirtoVuoro == Joukkue.PUNAINEN) {

                            } else if (siirtoVuoro == Joukkue.SININEN) {

                            }
                        }
                    } else if (valittuGladiaattori.getJoukkue() == siirtoVuoro) {//pelinTILA != TILA_PELI_ALKU
                        if (valittuGladiaattori.getLyo()) {
                            button_walk.draw(BUTTON_WALK_X, BUTTON_WALK_Y);
                        } else {
                            button_hit.draw(BUTTON_WALK_X, BUTTON_WALK_Y);
                        }
                        g.setColor(Color.black);
                        int x = (int)p.getX();
                        int y = (int)p.getY();
                        if (kavelymahdollisuudet == null) kavelymahdollisuudet = kavelymahdollisuudet(x, y);
                        if ((p2 == null) || p2.equals(p)) {
                            for (int xx = 0; xx < kavelymahdollisuudet.length; xx++) {
                               for (int yy = 0; yy < kavelymahdollisuudet[xx].length; yy++) {
                                   if (((kavelymahdollisuudet[xx][yy] == -1) && (valittuGladiaattori.getLyo())) && (valittuGladiaattori.getActionPisteet() >= valittuGladiaattori.getLyontiKustannus())) {
                                       if (siirtoVuoro == Joukkue.PUNAINEN) {
                                           sininen.draw(xx*RUUDUN_LEVEYS, yy*RUUDUN_KORKEUS);
                                       } else {
                                           punainen.draw(xx*RUUDUN_LEVEYS, yy*RUUDUN_KORKEUS);
                                       }
                                   } else if ((kavelymahdollisuudet[xx][yy] > 0) && (kavelymahdollisuudet[xx][yy]*valittuGladiaattori.getLiikkumisKustannus() <= valittuGladiaattori.getLiikkumisVara())) {
                                       if (siirtoVuoro == Joukkue.PUNAINEN) {
                                           punainen.draw(xx*RUUDUN_LEVEYS, yy*RUUDUN_KORKEUS);//VARJOSTETAAN RUUTU
                                       } else {
                                           sininen.draw(xx*RUUDUN_LEVEYS, yy*RUUDUN_KORKEUS);
                                       } 
                                       DecimalFormat df = new DecimalFormat("#");
                                       //DecimalFormat df = new DecimalFormat("#.#");
                                       g.drawString(df.format(kavelymahdollisuudet[xx][yy]*valittuGladiaattori.getLiikkumisKustannus()), xx*RUUDUN_LEVEYS, yy*RUUDUN_KORKEUS);//PIIRRETÄÄN ETÄISYYDET
                                    }
                               }
                            }
                        }
//                        if (kavelymahdollisuudet == null) kavelymahdollisuudet = kavelymahdollisuudet(x, y, 5);
//                        for (int xx = 0; xx < kavelymahdollisuudet.length; xx++) {
//                            for (int yy = 0; yy < kavelymahdollisuudet[xx].length; yy++) {
//                                if ((kavelymahdollisuudet[xx][yy] > 0) && (kavelymahdollisuudet[xx][yy] <= 5)) {
//                                    if (siirtoVuoro == Joukkue.PUNAINEN) {
//                                        punainen.draw((xx+x-5)*RUUDUN_LEVEYS, (yy+y-5)*RUUDUN_LEVEYS);//VARJOSTETAAN RUUTU
//                                    } else {
//                                        sininen.draw((xx+x-5)*RUUDUN_LEVEYS, (yy+y-5)*RUUDUN_LEVEYS);
//                                    }    
//                                    DecimalFormat df = new DecimalFormat("#.#");
//                                    g.drawString(df.format(kavelymahdollisuudet[xx][yy]), (xx+x-5)*RUUDUN_LEVEYS, (yy+y-5)*RUUDUN_LEVEYS);//PIIRRETÄÄN ETÄISYYDET
//                                }
//                            }
//                        }
                    }
                    if ((valittuGladiaattori.getReppu().getAvattu()) && !((pelinTila == TILA_PELI_PUNAINENVOITTI) || (pelinTila == TILA_PELI_SININENVOITTI))) {
                        g.setColor(Color.white);
                        g.fillRoundRect(50, 50, LEVEYS-2*50, KORKEUS-2*50, 10);
                        g.setColor(Color.black);
                        g.drawString(valittuGladiaattori.getReppu().toString(), 80, 80);
                        return;
                    }
                }
                
                
                for (int x = 0; x < XRUUTUJA; x++) {
                    for (int y = 0; y < YRUUTUJA; y++) {
                        Gladiaattori gladiaattori = ruudukko.getRuutu(x, y).getGladiaattori();
                        if (gladiaattori == null) continue;
                        gladiaattori.getImage().draw(x*RUUDUN_LEVEYS, y*RUUDUN_KORKEUS); //PIIRRETÄÄN GLADIAATTORIT
                    }
                }
                g.setColor(Color.black);
                for(int i = RUUDUN_LEVEYS; i < LEVEYS; i += RUUDUN_LEVEYS) {
                    g.drawLine(i, 0, i, KORKEUS);   //PIIRRETÄÄN RUUDUKKOA
                }
                for(int i = RUUDUN_KORKEUS; i < KORKEUS; i += RUUDUN_KORKEUS) {
                    g.drawLine(0, i, LEVEYS, i);
                }
                if ((pelinTila == TILA_PELI_PUNAINENVOITTI) || (pelinTila == TILA_PELI_SININENVOITTI)) {
                    for (int y = 0; y < KORKEUS-20; y = y+40) {
                        if (pelinTila == TILA_PELI_PUNAINENVOITTI) {
                            g.setColor(Color.red);
                            g.drawString("Red team won!", LEVEYS/2, y);
                        } else {
                            g.setColor(Color.blue);
                            g.drawString("Blue team won!", LEVEYS/2, y);
                        }
                    }
                }
	}
        
        private boolean inBox(final int x, final int y, final int x1, final int y1, final int x2, final int y2) {
            return (((x >= x1) && (y >= y1)) && ((x <= x2) && (y <= y2)));
        }
        
        @Override
        public void mousePressed(int button, int x, int y) {  
            System.out.println("Mouse button "+button+" was clicked at "+x+", "+y);
            if (button != 0) return; //Tarkkaillaan nyt vaan left clickejä.
            if (inBox(x, y, BUTTON_NEWGAME_X, BUTTON_NEWGAME_Y, BUTTON_NEWGAME_X+button_newgame.getWidth(), BUTTON_NEWGAME_Y+button_newgame.getHeight())) {
                pelinTila = TILA_PELI_ALOITA_UUSI;
                return;
            }
            if ((pelinTila == TILA_PELI_PUNAINENVOITTI) && (pelinTila == TILA_PELI_SININENVOITTI)) return;
            Gladiaattori g = ruudukko.getValittuGladiaattori();
            if ((g != null) && (inBox(x, y, BUTTON_BAG_X, BUTTON_BAG_Y, BUTTON_BAG_X+button_bag.getWidth(), BUTTON_BAG_Y+button_bag.getHeight()))) {
                g.getReppu().setAvattu(!g.getReppu().getAvattu());
                return;
            }
            if ((g != null) && g.getReppu().getAvattu()) {
                if ((g.getJoukkue() == siirtoVuoro) && (inBox(x, y, 80, 100, LEVEYS-80, KORKEUS-80))) {
                    g.getReppu().pueTavara((y-100)/20);
                    kavelymahdollisuudet = null;
                    System.out.println("Puetaan tavaraa "+(y-100)/20);
                }
                return;
            }
            if ((pelinTila == TILA_PELI) && inBox(x, y, BUTTON_ENDTURN_X, BUTTON_ENDTURN_Y, BUTTON_ENDTURN_X+button_endturn.getWidth(), BUTTON_ENDTURN_Y+button_endturn.getHeight())) {
                vaihdaVuoroa();
                return;
            }
            if ((g != null) && inBox(x, y, BUTTON_WALK_X, BUTTON_WALK_Y, BUTTON_WALK_X+button_walk.getWidth(), BUTTON_WALK_Y+button_walk.getHeight())) {
                if (g.getJoukkue() == siirtoVuoro) {
                    g.setLyo(!g.getLyo());
                    return;
                }
            }
            
            
            
            int xr = (x/RUUDUN_LEVEYS);
            int yr = (y/RUUDUN_LEVEYS);
            if ((xr < XRUUTUJA) && (yr < YRUUTUJA)) {
                System.out.println("Ruutua ("+xr+", "+yr+") clikattiin.");
                
                
                if (ruudukko.getRuutu(xr, yr).getGladiaattori() != null) {//Klikatussa ruudussa on gladiaattori
                    Gladiaattori klikattuGladiaattori = ruudukko.getRuutu(xr, yr).getGladiaattori();
                    Point p = ruudukko.getValittuLocation();
                    Point p2 = ruudukko.getVuoroLocation();
                    if (((((g != null) && g.getLyo()) && ((p2 == null) || p.equals(p2))) && (klikattuGladiaattori.getJoukkue() != siirtoVuoro)) && (pelinTila == TILA_PELI)) {
                        if (((Point2D.distance(xr, yr, p.getX(), p.getY()) <= g.getKantomatka()) && (g.getActionPisteet() >= g.getLyontiKustannus())) && (g.getJoukkue() == siirtoVuoro)){
                            g.vahennaActionPisteita(g.getLyontiKustannus());
                            kavelymahdollisuudet = null;
                            //if (!ruudukko.getRuutu(xr, yr).getGladiaattori().vahennaElamia(5)) {
                            if (!g.iskeGladiaattoria(ruudukko.getRuutu(xr, yr).getGladiaattori())) {
                                ruudukko.getRuutu(xr, yr).setGladiaattori(null);
                                if (Gladiaattori.sinisetGladiaattorit.size() == 0) pelinTila = TILA_PELI_PUNAINENVOITTI;
                                if (Gladiaattori.punaisetGladiaattorit.size() == 0) pelinTila = TILA_PELI_SININENVOITTI;
                                return;
                            }
                            return;
                        }
                    }
                    if ((p != null) && (((int)p.getX() != xr) || ((int)p.getY() != yr))) kavelymahdollisuudet = null;
                    ruudukko.setValittu(xr, yr);
                } else { //Klikatussa ruudussa ei ole gladiaattoria
                    if (ruudukko.getValittu() == null) return;
                    if (pelinTila == TILA_PELI_ALKU) {
                        if (g.getJoukkue() != Joukkue.TYHJA) return;
                        if ((siirtoVuoro == Joukkue.PUNAINEN) && (yr > XRUUTUJA-4)) {
                            ruudukko.getValittu().setGladiaattori(null);
                            g.setJoukkue(Joukkue.PUNAINEN);
                            ruudukko.getRuutu(xr, yr).setGladiaattori(g);
                            ruudukko.setValittu(null);
                            siirtoVuoro = Joukkue.SININEN;
                            valittuja++;
                        } else if ((siirtoVuoro == Joukkue.SININEN) && (yr < 3)) {
                            ruudukko.getValittu().setGladiaattori(null);
                            g.setJoukkue(Joukkue.SININEN);
                            ruudukko.getRuutu(xr, yr).setGladiaattori(g);
                            ruudukko.setValittu(null);
                            siirtoVuoro = Joukkue.PUNAINEN;
                            valittuja++;
                        }
                        if (valittuja >= MONTAKO_VALITAAN) pelinTila = TILA_PELI;
                    } else if ((g.getJoukkue() == siirtoVuoro) && (siirry(xr, yr, 1.0*g.getLiikkumisVara()/g.getLiikkumisKustannus()) > 0)) {
                        if ((ruudukko.getVuoro() != null) && (!ruudukko.getVuoro().equals(ruudukko.getValittu()))) return;
                        g.vahennaActionPisteita((int)(siirry(xr, yr, 1.0*g.getLiikkumisVara()/g.getLiikkumisKustannus())*g.getLiikkumisKustannus()));
                        kavelymahdollisuudet = null;
                        ruudukko.vaihdaRuudut(ruudukko.getValittu().getX(), ruudukko.getValittu().getY(), xr, yr);
                        ruudukko.setValittu(xr, yr);
                        ruudukko.setVuoro(xr, yr);
                    }           
                }
            }
        }
        
        @Override
        public void keyPressed(int key, char c) {
            System.out.println("Key #"+key+" was pressed. Char = "+c);
        }


        private double[][] kavelymahdollisuudet(final int aloitusX, final int aloitusY) {
            ArrayList<Point> pA = new ArrayList<Point>();
            pA.add(new Point(aloitusX, aloitusY));
            double[][] matriisi = new double[XRUUTUJA][YRUUTUJA];
            for (int i = 0; i<pA.size(); i++) {
               for (int x = Math.max(0, (int)pA.get(i).getX()-1); x <= Math.min(XRUUTUJA, (int)pA.get(i).getX()+1); x++) {
                   if ((x < 0) || (x >= XRUUTUJA)) continue;
                   for (int y = Math.max(0, (int)pA.get(i).getY()-1); y <= Math.min(YRUUTUJA, (int)pA.get(i).getY()+1); y++) {
                        if ((x == (int)pA.get(i).getX()) && (y == (int)pA.get(i).getY()) || ((x == aloitusX) && (y == aloitusY))) continue;
                        if ((y < 0) || (y >= YRUUTUJA)) continue;
                        if (ruudukko.getRuutu(x, y).kaveltava()) {
                            int oldx = (int)pA.get(i).getX();
                            int oldy = (int)pA.get(i).getY();
                            int newx = x;
                            int newy = y;
                            double distToNew = Point2D.distance(oldx, oldy, newx, newy);
                            if ((matriisi[newx][newy] == 0) || (matriisi[newx][newy] > matriisi[oldx][oldy]+distToNew)) {
                                matriisi[newx][newy] = matriisi[oldx][oldy]+distToNew;
                                pA.add(new Point(x, y));
                            }
                        } else {
                            Gladiaattori g = ruudukko.getRuutu(x, y).getGladiaattori();
                            if ((g == null) || (g.getJoukkue() == siirtoVuoro)) continue;
                            if ((ruudukko.getValittuGladiaattori() != null) && (Point2D.distance(aloitusX, aloitusY, x, y) <= ruudukko.getValittuGladiaattori().getKantomatka())) {
                                    matriisi[x][y] = -1;
                            }
                        }
                   }                 
               }
            }
            return matriisi;           
        }
        
        
        private double[][] kavelymahdollisuudet2(final int aloitusX, final int aloitusY, int liikkumisKustannus) {
            ArrayList<Point> pA = new ArrayList<Point>();
            pA.add(new Point(aloitusX, aloitusY));
            double[][] matriisi = new double[XRUUTUJA][YRUUTUJA];
            for (int i = 0; i<pA.size(); i++) {
               for (int x = Math.max(0, (int)pA.get(i).getX()-1); x <= Math.min(XRUUTUJA, (int)pA.get(i).getX()+1); x++) {
                   if ((x < 0) || (x >= XRUUTUJA)) continue;
                   for (int y = Math.max(0, (int)pA.get(i).getY()-1); y <= Math.min(YRUUTUJA, (int)pA.get(i).getY()+1); y++) {
                        if ((x == (int)pA.get(i).getX()) && (y == (int)pA.get(i).getY()) || ((x == aloitusX) && (y == aloitusY))) continue;
                        if ((y < 0) || (y >= YRUUTUJA)) continue;
                        if (ruudukko.getRuutu(x, y).kaveltava()) {
                            int oldx = (int)pA.get(i).getX();
                            int oldy = (int)pA.get(i).getY();
                            int newx = x;
                            int newy = y;
                            double distToNew = Point2D.distance(oldx, oldy, newx, newy)*liikkumisKustannus;
                            if ((matriisi[newx][newy] == 0) || (matriisi[newx][newy] > matriisi[oldx][oldy]+distToNew)) {
                                matriisi[newx][newy] = matriisi[oldx][oldy]+distToNew;
                                pA.add(new Point(x, y));
                            }
                        }
                   }                 
               }
            }
            return matriisi;           
        }
        
        //Varalla tallella..
        private double[][] kavelymahdollisuudet3(final int aloitusX, final int aloitusY, final int maxdist) {
            ArrayList<Point> pA = new ArrayList<Point>();
            pA.add(new Point(aloitusX, aloitusY));
            double[][] matriisi = new double[maxdist*2+1][maxdist*2+1];
            for (int i = 0; i<pA.size(); i++) {
               for (int x = Math.max(aloitusX-maxdist, (int)pA.get(i).getX()-1); x <= Math.min(aloitusX+maxdist, (int)pA.get(i).getX()+1); x++) {
                   if ((x < 0) || (x >= XRUUTUJA)) continue;
                   for (int y = Math.max(aloitusY-maxdist, (int)pA.get(i).getY()-1); y <= Math.min(aloitusY+maxdist, (int)pA.get(i).getY()+1); y++) {
                        if ((x == (int)pA.get(i).getX()) && (y == (int)pA.get(i).getY()) || ((x == aloitusX) && (y == aloitusY))) continue;
                        if ((y < 0) || (y >= YRUUTUJA)) continue;
                        if (ruudukko.getRuutu(x, y).kaveltava()) {
                            int oldx = (matriisi.length-1)/2+(int)pA.get(i).getX()-aloitusX;
                            int oldy = (matriisi.length-1)/2+(int)pA.get(i).getY()-aloitusY;
                            int newx = (matriisi.length-1)/2+x-aloitusX;
                            int newy = (matriisi.length-1)/2+y-aloitusY;
                            double distToNew = Point2D.distance(oldx, oldy, newx, newy);
                            if ((matriisi[newx][newy] == 0) || (matriisi[newx][newy] > matriisi[oldx][oldy]+distToNew)) {
                                matriisi[newx][newy] = matriisi[oldx][oldy]+distToNew;
                                pA.add(new Point(x, y));
                            }
                        }
                   }                 
               }
            }
//            for (int i = 0; i < matriisi.length; i++) {
//                for (int ii = 0; ii < matriisi.length; ii++) {
//                  System.out.print(Math.round(matriisi[ii][i]));
//                }
//                System.out.println("");
//            }
//            System.out.println("");
//            System.out.println("");
//            System.out.println("");
//            System.out.println("");
            return matriisi;           
        }
        
        private double siirry(final int lopetusX, final int lopetusY, final double maxdist) {
            double dist = kavelymahdollisuudet[lopetusX][lopetusY];
            if (dist <= maxdist) return dist;
            else return -1;
        }
        
        
        //Varalla tallella..
        private double siirry2(final int aloitusX, final int aloitusY, final int lopetusX, final int lopetusY, final double maxdist) {
            if (Point2D.distance(aloitusX, aloitusY, lopetusX, lopetusY) > maxdist) return -1;
            ArrayList<Point> pA = new ArrayList<Point>();
            pA.add(new Point(aloitusX, aloitusY));
            double[][] matriisi = new double[(int)maxdist*2+1][(int)maxdist*2+1];
            for (int i = 0; i<pA.size(); i++) {
               for (int x = Math.max(aloitusX-(int)maxdist, (int)pA.get(i).getX()-1); x <= Math.min(aloitusX+(int)maxdist, (int)pA.get(i).getX()+1); x++) {
                   if ((x < 0) || (x >= XRUUTUJA)) continue;
                   for (int y = Math.max(aloitusY-(int)maxdist, (int)pA.get(i).getY()-1); y <= Math.min(aloitusY+(int)maxdist, (int)pA.get(i).getY()+1); y++) {
                        if ((x == (int)pA.get(i).getX()) && (y == (int)pA.get(i).getY()) || ((x == aloitusX) && (y == aloitusY))) continue;
                        if ((y < 0) || (y >= YRUUTUJA)) continue;
                        if (ruudukko.getRuutu(x, y).kaveltava()) {
                            int oldx = (matriisi.length-1)/2+(int)pA.get(i).getX()-aloitusX;
                            int oldy = (matriisi.length-1)/2+(int)pA.get(i).getY()-aloitusY;
                            int newx = (matriisi.length-1)/2+x-aloitusX;
                            int newy = (matriisi.length-1)/2+y-aloitusY;
                            double distToNew = Point2D.distance(oldx, oldy, newx, newy);
                            if ((matriisi[newx][newy] == 0) || (matriisi[newx][newy] > matriisi[oldx][oldy]+distToNew)) {
                                matriisi[newx][newy] = matriisi[oldx][oldy]+distToNew;
                                if ((lopetusX == newx-maxdist+aloitusX) && (lopetusY == newy-maxdist+aloitusY)) return matriisi[newx][newy];
                                pA.add(new Point(x, y));
                            }
                        }
                   }                 
               }
            }
            return -1;
        } 
        
        
        public void vaihdaVuoroa() {
            ruudukko.setValittu(null);
            ruudukko.setVuoro(null);
            kavelymahdollisuudet = null;
            for (int i = 0; i < Gladiaattori.punaisetGladiaattorit.size(); i++) {
                Gladiaattori.punaisetGladiaattorit.get(i).lisaaActionPisteita(5);
            }
            for (int i = 0; i < Gladiaattori.sinisetGladiaattorit.size(); i++) {
                Gladiaattori.sinisetGladiaattorit.get(i).lisaaActionPisteita(5);
            }
            if (siirtoVuoro == Joukkue.PUNAINEN) {
                siirtoVuoro = Joukkue.SININEN;
            } else {
                siirtoVuoro = Joukkue.PUNAINEN;
            }
        }
        

	public static void main(String[] args) throws SlickException {
                System.setProperty("org.lwjgl.librarypath", new File(new File(System.getProperty("user.dir"), "native"), LWJGLUtil.getPlatformName()).getAbsolutePath());
                System.setProperty("net.java.games.input.librarypath", System.getProperty("org.lwjgl.librarypath"));
		AppGameContainer app = new AppGameContainer(new GladiatorManager());
                app.setShowFPS(false);
		app.setDisplayMode(LEVEYS+INFO_LEVEYS, KORKEUS+TEKSTI_KORKEUS, false);
		app.setTargetFrameRate(50);
		app.start();
	}
}